home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / sbin / functions.sh < prev    next >
Encoding:
Text File  |  2006-04-25  |  17.6 KB  |  857 lines
  1. # Copyright 1999-2005 Gentoo Foundation
  2. # Distributed under the terms of the GNU General Public License v2
  3.  
  4. RC_GOT_FUNCTIONS="yes"
  5.  
  6. # Override defaults with user settings ...
  7. [ -f /etc/conf.d/rc ] && source /etc/conf.d/rc
  8.  
  9. # daemontools dir
  10. SVCDIR="/var/lib/supervise"
  11.  
  12. # Check /etc/conf.d/rc for a description of these ...
  13. svclib="/lib/rcscripts"
  14. svcdir=${svcdir:-/var/lib/init.d}
  15. svcmount=${svcmount:-no}
  16. svcfstype=${svcfstype:-tmpfs}
  17. svcsize=${svcsize:-1024}
  18.  
  19. # Different types of dependencies
  20. deptypes="need use"
  21. # Different types of order deps
  22. ordtypes="before after"
  23.  
  24. #
  25. # Internal variables
  26. #
  27.  
  28. # Dont output to stdout?
  29. RC_QUIET_STDOUT="no"
  30. RC_VERBOSE=${RC_VERBOSE:-no}
  31.  
  32. # Should we use color?
  33. RC_NOCOLOR=${RC_NOCOLOR:-no}
  34. # Can the terminal handle endcols?
  35. RC_ENDCOL="yes"
  36.  
  37. #
  38. # Default values for rc system
  39. #
  40. RC_TTY_NUMBER=${RC_TTY_NUMBER:-11}
  41. RC_PARALLEL_STARTUP=${RC_PARALLEL_STARTUP:-no}
  42. RC_NET_STRICT_CHECKING=${RC_NET_STRICT_CHECKING:-no}
  43. RC_VOLUME_ORDER=${RC_VOLUME_ORDER:-raid evms lvm dm}
  44. RC_USE_FSTAB=${RC_USE_FSTAB:-no}
  45. RC_USE_CONFIG_PROFILE=${RC_USE_CONFIG_PROFILE:-yes}
  46. RC_FORCE_AUTO=${RC_FORCE_AUTO:-no}
  47. RC_DEVICES=${RC_DEVICES:-auto}
  48.  
  49. #
  50. # Default values for e-message indentation and dots
  51. #
  52. RC_INDENTATION=''
  53. RC_DEFAULT_INDENT=2
  54. #RC_DOT_PATTERN=' .'
  55. RC_DOT_PATTERN=''
  56.  
  57. # void import_addon(char *addon)
  58. #
  59. #  Import code from the specified addon if it exists
  60. #
  61. import_addon() {
  62.     local addon=${svclib}/addons/$1
  63.     if [[ -r ${addon} ]] ; then
  64.         source "${addon}"
  65.         return 0
  66.     fi
  67.     return 1
  68. }
  69.  
  70. # void splash(...)
  71. #
  72. #  Notify bootsplash/splashutils/gensplash/whatever about
  73. #  important events.
  74. #
  75. splash() {
  76.     return 0
  77. }
  78. # This will override the splash() function...
  79. if ! import_addon splash-functions.sh ; then
  80.     [ -f /sbin/splash-functions.sh ] && source /sbin/splash-functions.sh
  81. fi
  82.  
  83. # void profiling(...)
  84. #
  85. #  Notify bootsplash/whatever about important events.
  86. #
  87. profiling() {
  88.     return 0
  89. }
  90. import_addon profiling-functions.sh
  91.  
  92. # void bootlog(...)
  93. #
  94. #  Notify bootlogger about important events.
  95. bootlog() {
  96.     return 0
  97. }
  98. [[ ${RC_BOOTLOG} == "yes" ]] && import_addon bootlogger.sh
  99.  
  100. # void get_bootconfig()
  101. #
  102. #    Get the BOOTLEVEL and SOFTLEVEL by setting
  103. #    'bootlevel' and 'softlevel' via kernel
  104. #    parameters.
  105. #
  106. get_bootconfig() {
  107.     local copt=
  108.     local newbootlevel=
  109.     local newsoftlevel=
  110.  
  111.     if [[ -r /proc/cmdline ]] ; then
  112.         for copt in $(</proc/cmdline) ; do
  113.             case "${copt%=*}" in
  114.                 bootlevel)
  115.                     newbootlevel=${copt##*=}
  116.                     ;;
  117.                 softlevel)
  118.                     newsoftlevel=${copt##*=}
  119.                     ;;
  120.             esac
  121.         done
  122.     fi
  123.  
  124.     if [[ -n ${newbootlevel} ]] ; then
  125.         export BOOTLEVEL=${newbootlevel}
  126.     else
  127.         export BOOTLEVEL="boot"
  128.     fi
  129.  
  130.     if [[ -n ${newsoftlevel} ]] ; then
  131.         export DEFAULTLEVEL=${newsoftlevel}
  132.     else
  133.         export DEFAULTLEVEL="default"
  134.     fi
  135.  
  136.     return 0
  137. }
  138.  
  139. setup_defaultlevels() {
  140.     get_bootconfig
  141.  
  142.     if get_bootparam "noconfigprofile" ; then
  143.         export RC_USE_CONFIG_PROFILE="no"
  144.  
  145.     elif get_bootparam "configprofile" ; then
  146.         export RC_USE_CONFIG_PROFILE="yes"
  147.     fi
  148.  
  149.     if [ "${RC_USE_CONFIG_PROFILE}" = "yes" -a -n "${DEFAULTLEVEL}" ] && \
  150.        [ -d "/etc/runlevels/${BOOTLEVEL}.${DEFAULTLEVEL}" -o \
  151.          -L "/etc/runlevels/${BOOTLEVEL}.${DEFAULTLEVEL}" ]
  152.     then
  153.         export BOOTLEVEL="${BOOTLEVEL}.${DEFAULTLEVEL}"
  154.     fi
  155.  
  156.     if [ -z "${SOFTLEVEL}" ] ; then
  157.         if [ -f "${svcdir}/softlevel" ] ; then
  158.             export SOFTLEVEL="$(< ${svcdir}/softlevel)"
  159.         else
  160.             export SOFTLEVEL="${BOOTLEVEL}"
  161.         fi
  162.     fi
  163.  
  164.     return 0
  165. }
  166.  
  167. # void get_libdir(void)
  168. #
  169. #    prints the current libdir {lib,lib32,lib64}
  170. #
  171. get_libdir() {
  172.     if [ -n "${CONF_LIBDIR_OVERRIDE}" ] ; then
  173.         CONF_LIBDIR="${CONF_LIBDIR_OVERRIDE}"
  174.     elif [ -x "/usr/bin/portageq" ] ; then
  175.         CONF_LIBDIR="$(/usr/bin/portageq envvar CONF_LIBDIR)"
  176.     fi
  177.     echo ${CONF_LIBDIR:=lib}
  178. }
  179.  
  180. # void esyslog(char* priority, char* tag, char* message)
  181. #
  182. #    use the system logger to log a message
  183. #
  184. esyslog() {
  185.     local pri=
  186.     local tag=
  187.  
  188.     if [ -x /usr/bin/logger ]
  189.     then
  190.         pri="$1"
  191.         tag="$2"
  192.  
  193.         shift 2
  194.         [[ -z "$*" ]] && return 0
  195.  
  196.         /usr/bin/logger -p "${pri}" -t "${tag}" -- "$*"
  197.     fi
  198.  
  199.     return 0
  200. }
  201.  
  202. # void eindent(int num)
  203. #
  204. #    increase the indent used for e-commands.
  205. #
  206. eindent() {
  207.     local i=$1
  208.     (( i > 0 )) || (( i = RC_DEFAULT_INDENT ))
  209.     esetdent $(( ${#RC_INDENTATION} + i ))
  210. }
  211.  
  212. # void eoutdent(int num)
  213. #
  214. #    decrease the indent used for e-commands.
  215. #
  216. eoutdent() {
  217.     local i=$1
  218.     (( i > 0 )) || (( i = RC_DEFAULT_INDENT ))
  219.     esetdent $(( ${#RC_INDENTATION} - i ))
  220. }
  221.  
  222. # void esetdent(int num)
  223. #
  224. #    hard set the indent used for e-commands.
  225. #    num defaults to 0
  226. #
  227. esetdent() {
  228.     local i=$1
  229.     (( i < 0 )) && (( i = 0 ))
  230.     RC_INDENTATION=$(printf "%${i}s" '')
  231. }
  232.  
  233. # void einfo(char* message)
  234. #
  235. #    show an informative message (with a newline)
  236. #
  237. einfo() {
  238.     einfon "$*\n"
  239.     LAST_E_CMD=einfo
  240.     return 0
  241. }
  242.  
  243. # void einfon(char* message)
  244. #
  245. #    show an informative message (without a newline)
  246. #
  247. einfon() {
  248.     [[ ${RC_QUIET_STDOUT} == yes ]] && return 0
  249.     [[ ${RC_ENDCOL} != yes && ${LAST_E_CMD} == ebegin ]] && echo
  250.     echo -ne " ${GOOD}*${NORMAL} ${RC_INDENTATION}$*"
  251.     LAST_E_CMD=einfon
  252.     return 0
  253. }
  254.  
  255. # void ewarn(char* message)
  256. #
  257. #    show a warning message + log it
  258. #
  259. ewarn() {
  260.     if [[ ${RC_QUIET_STDOUT} == yes ]]; then
  261.         echo " $*"
  262.     else
  263.         [[ ${RC_ENDCOL} != yes && ${LAST_E_CMD} == ebegin ]] && echo
  264.         echo -e " ${WARN}*${NORMAL} ${RC_INDENTATION}$*"
  265.     fi
  266.  
  267.     # Log warnings to system log
  268.     esyslog "daemon.warning" "rc-scripts" "$*"
  269.  
  270.     LAST_E_CMD=ewarn
  271.     return 0
  272. }
  273.  
  274. # void eerror(char* message)
  275. #
  276. #    show an error message + log it
  277. #
  278. eerror() {
  279.     if [[ ${RC_QUIET_STDOUT} == yes ]]; then
  280.         echo " $*" >/dev/stderr
  281.     else
  282.         [[ ${RC_ENDCOL} != yes && ${LAST_E_CMD} == ebegin ]] && echo
  283.         echo -e " ${BAD}*${NORMAL} ${RC_INDENTATION}$*"
  284.     fi
  285.  
  286.     # Log errors to system log
  287.     esyslog "daemon.err" "rc-scripts" "$*"
  288.  
  289.     LAST_E_CMD=eerror
  290.     return 0
  291. }
  292.  
  293. # void ebegin(char* message)
  294. #
  295. #    show a message indicating the start of a process
  296. #
  297. ebegin() {
  298.     local msg="$*" dots spaces=${RC_DOT_PATTERN//?/ }
  299.     [[ ${RC_QUIET_STDOUT} == yes ]] && return 0
  300.  
  301.     if [[ -n ${RC_DOT_PATTERN} ]]; then
  302.         dots=$(printf "%$(( COLS - 3 - ${#RC_INDENTATION} - ${#msg} - 7 ))s" '')
  303.         dots=${dots//${spaces}/${RC_DOT_PATTERN}}
  304.         msg="${msg}${dots}"
  305.     else
  306.         msg="${msg} ..."
  307.     fi
  308.     einfon "${msg}"
  309.     [[ ${RC_ENDCOL} == yes ]] && echo
  310.  
  311.     LAST_E_LEN=$(( 3 + ${#RC_INDENTATION} + ${#msg} ))
  312.     LAST_E_CMD=ebegin
  313.     return 0
  314. }
  315.  
  316. # void _eend(int error, char *efunc, char* errstr)
  317. #
  318. #    indicate the completion of process, called from eend/ewend
  319. #    if error, show errstr via efunc
  320. #
  321. #    This function is private to functions.sh.  Do not call it from a
  322. #    script.
  323. #
  324. _eend() {
  325.     local retval=${1:-0} efunc=${2:-eerror} msg
  326.     shift 2
  327.  
  328.     if [[ ${retval} == 0 ]]; then
  329.         [[ ${RC_QUIET_STDOUT} == yes ]] && return 0
  330.         msg="${BRACKET}[ ${GOOD}ok${BRACKET} ]${NORMAL}"
  331.     else
  332.         if [[ -c /dev/null ]]; then
  333.             rc_splash "stop" &>/dev/null &
  334.         else
  335.             rc_splash "stop" &
  336.         fi
  337.         if [[ -n "$*" ]]; then
  338.             ${efunc} "$*"
  339.         fi
  340.         msg="${BRACKET}[ ${BAD}!!${BRACKET} ]${NORMAL}"
  341.     fi
  342.  
  343.     if [[ ${RC_ENDCOL} == yes ]]; then
  344.         echo -e "${ENDCOL}  ${msg}"
  345.     else
  346.         [[ ${LAST_E_CMD} == ebegin ]] || LAST_E_LEN=0
  347.         printf "%$(( COLS - LAST_E_LEN - 6 ))s%b\n" '' "${msg}"
  348.     fi
  349.  
  350.     return ${retval}
  351. }
  352.  
  353. # void eend(int error, char* errstr)
  354. #
  355. #    indicate the completion of process
  356. #    if error, show errstr via eerror
  357. #
  358. eend() {
  359.     local retval=${1:-0}
  360.     shift
  361.  
  362.     _eend ${retval} eerror "$*"
  363.  
  364.     LAST_E_CMD=eend
  365.     return $retval
  366. }
  367.  
  368. # void ewend(int error, char* errstr)
  369. #
  370. #    indicate the completion of process
  371. #    if error, show errstr via ewarn
  372. #
  373. ewend() {
  374.     local retval=${1:-0}
  375.     shift
  376.  
  377.     _eend ${retval} ewarn "$*"
  378.  
  379.     LAST_E_CMD=ewend
  380.     return $retval
  381. }
  382.  
  383. # v-e-commands honor RC_VERBOSE which defaults to no.
  384. # The condition is negated so the return value will be zero.
  385. veinfo() { [[ "${RC_VERBOSE}" != yes ]] || einfo "$@"; }
  386. veinfon() { [[ "${RC_VERBOSE}" != yes ]] || einfon "$@"; }
  387. vewarn() { [[ "${RC_VERBOSE}" != yes ]] || ewarn "$@"; }
  388. veerror() { [[ "${RC_VERBOSE}" != yes ]] || eerror "$@"; }
  389. vebegin() { [[ "${RC_VERBOSE}" != yes ]] || ebegin "$@"; }
  390. veend() {
  391.     [[ "${RC_VERBOSE}" == yes ]] && { eend "$@"; return $?; }
  392.     return ${1:-0}
  393. }
  394. veend() {
  395.     [[ "${RC_VERBOSE}" == yes ]] && { ewend "$@"; return $?; }
  396.     return ${1:-0}
  397. }
  398.  
  399. # char *KV_major(string)
  400. #
  401. #    Return the Major (X of X.Y.Z) kernel version
  402. #
  403. KV_major() {
  404.     [[ -z $1 ]] && return 1
  405.  
  406.     local KV=$@
  407.     echo ${KV%%.*}
  408. }
  409.  
  410. # char *KV_minor(string)
  411. #
  412. #    Return the Minor (Y of X.Y.Z) kernel version
  413. #
  414. KV_minor() {
  415.     [[ -z $1 ]] && return 1
  416.  
  417.     local KV=$@
  418.     KV=${KV#*.}
  419.     echo ${KV%%.*}
  420. }
  421.  
  422. # char *KV_micro(string)
  423. #
  424. #    Return the Micro (Z of X.Y.Z) kernel version.
  425. #
  426. KV_micro() {
  427.     [[ -z $1 ]] && return 1
  428.  
  429.     local KV=$@
  430.     KV=${KV#*.*.}
  431.     echo ${KV%%[^[:digit:]]*}
  432. }
  433.  
  434. # int KV_to_int(string)
  435. #
  436. #    Convert a string type kernel version (2.4.0) to an int (132096)
  437. #    for easy compairing or versions ...
  438. #
  439. KV_to_int() {
  440.     [[ -z $1 ]] && return 1
  441.  
  442.     local KV_MAJOR=$(KV_major "$1")
  443.     local KV_MINOR=$(KV_minor "$1")
  444.     local KV_MICRO=$(KV_micro "$1")
  445.     local KV_int=$(( KV_MAJOR * 65536 + KV_MINOR * 256 + KV_MICRO ))
  446.  
  447.     # We make version 2.2.0 the minimum version we will handle as
  448.     # a sanity check ... if its less, we fail ...
  449.     if [[ ${KV_int} -ge 131584 ]] ; then
  450.         echo "${KV_int}"
  451.         return 0
  452.     fi
  453.  
  454.     return 1
  455. }
  456.  
  457. # int get_KV()
  458. #
  459. #    Return the kernel version (major, minor and micro concated) as an integer.
  460. #    Assumes X and Y of X.Y.Z are numbers.  Also assumes that some leading
  461. #    portion of Z is a number.
  462. #    e.g. 2.4.25, 2.6.10, 2.6.4-rc3, 2.2.40-poop, 2.0.15+foo
  463. #
  464. get_KV() {
  465.     local KV=$(uname -r)
  466.  
  467.     echo $(KV_to_int "${KV}")
  468.  
  469.     return $?
  470. }
  471.  
  472. # bool get_bootparam(param)
  473. #
  474. #   return 0 if gentoo=param was passed to the kernel
  475. #
  476. #   EXAMPLE:  if get_bootparam "nodevfs" ; then ....
  477. #
  478. get_bootparam() {
  479.     local x copt params retval=1
  480.  
  481.     [ ! -r "/proc/cmdline" ] && return 1
  482.  
  483.     for copt in $(< /proc/cmdline)
  484.     do
  485.         if [ "${copt%=*}" = "gentoo" ]
  486.         then
  487.             params="$(gawk -v PARAMS="${copt##*=}" '
  488.                 BEGIN {
  489.                     split(PARAMS, nodes, ",")
  490.                     for (x in nodes)
  491.                         print nodes[x]
  492.                 }')"
  493.  
  494.             # Parse gentoo option
  495.             for x in ${params}
  496.             do
  497.                 if [ "${x}" = "$1" ]
  498.                 then
  499. #                    echo "YES"
  500.                     retval=0
  501.                 fi
  502.             done
  503.         fi
  504.     done
  505.  
  506.     return ${retval}
  507. }
  508.  
  509. # Safer way to list the contents of a directory,
  510. # as it do not have the "empty dir bug".
  511. #
  512. # char *dolisting(param)
  513. #
  514. #    print a list of the directory contents
  515. #
  516. #    NOTE: quote the params if they contain globs.
  517. #          also, error checking is not that extensive ...
  518. #
  519. dolisting() {
  520.     local x=
  521.     local y=
  522.     local tmpstr=
  523.     local mylist=
  524.     local mypath="$*"
  525.  
  526.     if [ "${mypath%/\*}" != "${mypath}" ]
  527.     then
  528.         mypath="${mypath%/\*}"
  529.     fi
  530.  
  531.     for x in ${mypath}
  532.     do
  533.         [ ! -e "${x}" ] && continue
  534.  
  535.         if [ ! -d "${x}" ] && ( [ -L "${x}" -o -f "${x}" ] )
  536.         then
  537.             mylist="${mylist} $(ls "${x}" 2> /dev/null)"
  538.         else
  539.             [ "${x%/}" != "${x}" ] && x="${x%/}"
  540.  
  541.             cd "${x}"; tmpstr="$(ls)"
  542.  
  543.             for y in ${tmpstr}
  544.             do
  545.                 mylist="${mylist} ${x}/${y}"
  546.             done
  547.         fi
  548.     done
  549.  
  550.     echo "${mylist}"
  551. }
  552.  
  553. # void save_options(char *option, char *optstring)
  554. #
  555. #    save the settings ("optstring") for "option"
  556. #
  557. save_options() {
  558.     local myopts="$1"
  559.  
  560.     shift
  561.     if [ ! -d "${svcdir}/options/${myservice}" ]
  562.     then
  563.         mkdir -p -m 0755 "${svcdir}/options/${myservice}"
  564.     fi
  565.  
  566.     echo "$*" > "${svcdir}/options/${myservice}/${myopts}"
  567.  
  568.     return 0
  569. }
  570.  
  571. # char *get_options(char *option)
  572. #
  573. #    get the "optstring" for "option" that was saved
  574. #    by calling the save_options function
  575. #
  576. get_options() {
  577.     if [ -f "${svcdir}/options/${myservice}/$1" ]
  578.     then
  579.         echo "$(< ${svcdir}/options/${myservice}/$1)"
  580.     fi
  581.  
  582.     return 0
  583. }
  584.  
  585. # char *add_suffix(char * configfile)
  586. #
  587. #    Returns a config file name with the softlevel suffix
  588. #    appended to it.  For use with multi-config services.
  589. add_suffix() {
  590.     if [ "${RC_USE_CONFIG_PROFILE}" = "yes" -a -e "$1.${DEFAULTLEVEL}" ]
  591.     then
  592.         echo "$1.${DEFAULTLEVEL}"
  593.     else
  594.         echo "$1"
  595.     fi
  596.  
  597.     return 0
  598. }
  599.  
  600. # char *get_base_ver()
  601. #
  602. #    get the version of baselayout that this system is running
  603. #
  604. get_base_ver() {
  605.     [[ ! -r /etc/gentoo-release ]] && return 0
  606.     local ver=$(</etc/gentoo-release)
  607.     echo ${ver##* }
  608. }
  609.  
  610. # Network filesystems list for common use in rc-scripts.
  611. # This variable is used in is_net_fs and other places such as
  612. # localmount.
  613. NET_FS_LIST="afs cifs coda davfs gfs ncpfs nfs nfs4 ocfs2 shfs smbfs"
  614.  
  615. # bool is_net_fs(path)
  616. #
  617. #   return 0 if path is the mountpoint of a networked filesystem
  618. #
  619. #   EXAMPLE:  if is_net_fs / ; then ...
  620. #
  621. is_net_fs() {
  622.     local fstype
  623.     # /proc/mounts is always accurate but may not always be available
  624.     if [[ -e /proc/mounts ]]; then
  625.         fstype=$( sed -n -e '/^rootfs/!s:.* '"$1"' \([^ ]*\).*:\1:p' /proc/mounts )
  626.     else
  627.         fstype=$( mount | sed -n -e 's:.* on '"$1"' type \([^ ]*\).*:\1:p' )
  628.     fi
  629.     [[ " ${NET_FS_LIST} " == *" ${fstype} "* ]]
  630.     return $?
  631. }
  632.  
  633. # bool is_uml_sys()
  634. #
  635. #   return 0 if the currently running system is User Mode Linux
  636. #
  637. #   EXAMPLE:  if is_uml_sys ; then ...
  638. #
  639. is_uml_sys() {
  640.     grep -qs 'UML' /proc/cpuinfo
  641.     return $?
  642. }
  643.  
  644. # bool is_vserver_sys()
  645. #
  646. #   return 0 if the currently running system is a Linux VServer
  647. #
  648. #   EXAMPLE:  if is_vserver_sys ; then ...
  649. #
  650. is_vserver_sys() {
  651.     grep -qs '^s_context:[[:space:]]*[1-9]' /proc/self/status
  652.     return $?
  653. }
  654.  
  655. # bool is_xenU_sys()
  656. #
  657. #   return 0 if the currently running system is an unprivileged Xen domain
  658. #
  659. #   EXAMPLE:  if is_xenU_sys ; then ...
  660. #
  661. is_xenU_sys() {
  662.     [[ -d /proc/xen && ! -f /proc/xen/privcmd ]]
  663. }
  664.  
  665. # bool get_mount_fstab(path)
  666. #
  667. #   return the parameters to pass to the mount command generated from fstab
  668. #
  669. #   EXAMPLE: cmd=$( get_mount_fstab /proc )
  670. #            cmd=${cmd:--t proc none /proc}
  671. #            mount -n ${cmd}
  672. #
  673. get_mount_fstab() {
  674.     awk '$1 ~ "^#" { next }
  675.          $2 == "'$*'" { if (found++ == 0) { print "-t "$3,"-o "$4,$1,$2 } }
  676.          END { if (found > 1) { print "More than one entry for '$*' found in /etc/fstab!" > "/dev/stderr" } }
  677.     ' /etc/fstab
  678. }
  679.  
  680. # char *reverse_list(list)
  681. #
  682. #   Returns the reversed order of list
  683. #
  684. reverse_list() {
  685.     for (( i = $# ; i > 0 ; --i )); do
  686.         echo -n "${!i} "
  687.     done
  688. }
  689.  
  690. # void start_addon(addon)
  691. #
  692. #   Starts addon.
  693. #
  694. start_addon() {
  695.     local addon=$1
  696.     (import_addon ${addon}-start.sh)
  697.     return 0
  698. }
  699.  
  700. # void start_volumes()
  701. #
  702. #   Starts all volumes in RC_VOLUME_ORDER.
  703. #
  704. start_volumes() {
  705.     local x=
  706.  
  707.     for x in ${RC_VOLUME_ORDER}; do
  708.         start_addon "${x}"
  709.     done
  710.  
  711.     return 0
  712. }
  713.  
  714. # void stop_addon(addon)
  715. #
  716. #   Stops addon.
  717. #
  718. stop_addon() {
  719.     local addon=$1
  720.     (import_addon ${addon}-stop.sh)
  721.     return 0
  722. }
  723.  
  724. # void stop_volumes()
  725. #
  726. #   Stops all volumes in RC_VOLUME_ORDER (reverse order).
  727. #
  728. stop_volumes() {
  729.     local x=
  730.  
  731.     for x in $(reverse_list ${RC_VOLUME_ORDER}); do
  732.         stop_addon "${x}"
  733.     done
  734.  
  735.     return 0
  736. }
  737.  
  738. # bool is_older_than(reference, files/dirs to check)
  739. #
  740. #   return 0 if any of the files/dirs are newer than
  741. #   the reference file
  742. #
  743. #   EXAMPLE: if is_older_than a.out *.o ; then ...
  744. is_older_than() {
  745.     local x=
  746.     local ref="$1"
  747.     shift
  748.  
  749.     for x in "$@" ; do
  750.         [[ ${x} -nt ${ref} ]] && return 0
  751.  
  752.         if [[ -d ${x} ]] ; then
  753.             is_older_than "${ref}" "${x}"/* && return 0
  754.         fi
  755.     done
  756.  
  757.     return 1
  758. }
  759.  
  760. # char* uniqify(char *arg, ...)
  761. #
  762. #   Ensure that params are unique
  763. #
  764. uniqify() {
  765.     local result= x=
  766.     while [[ -n "$1" ]] ; do
  767.         [[ " ${result} " != *" $1 "* ]] && result="${result} $1"
  768.         shift
  769.     done
  770.     echo "${result# *}"
  771. }
  772.  
  773. ##############################################################################
  774. #                                                                            #
  775. # This should be the last code in here, please add all functions above!!     #
  776. #                                                                            #
  777. # *** START LAST CODE ***                                                    #
  778. #                                                                            #
  779. ##############################################################################
  780.  
  781. if [ -z "${EBUILD}" ] ; then
  782.     # Setup a basic $PATH.  Just add system default to existing.
  783.     # This should solve both /sbin and /usr/sbin not present when
  784.     # doing 'su -c foo', or for something like:  PATH= rcscript start
  785.     PATH="/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/sbin:${PATH}"
  786.  
  787.     if [ "$(/sbin/consoletype 2> /dev/null)" = "serial" ] ; then
  788.         # We do not want colors/endcols on serial terminals
  789.         RC_NOCOLOR="yes"
  790.         RC_ENDCOL="no"
  791.     fi
  792.  
  793.     for arg in "$@" ; do
  794.         case "${arg}" in
  795.             # Lastly check if the user disabled it with --nocolor argument
  796.             --nocolor|-nc)
  797.                 RC_NOCOLOR="yes"
  798.                 ;;
  799.         esac
  800.     done
  801.  
  802.     if [ -r "/proc/cmdline" ] ; then
  803.         setup_defaultlevels
  804.     fi
  805. else
  806.     # Should we use colors ?
  807.     if [[ $* != *depend* ]]; then
  808.         # Check user pref in portage
  809.         RC_NOCOLOR="$(portageq envvar NOCOLOR 2>/dev/null)"
  810.         [ "${RC_NOCOLOR}" = "true" ] && RC_NOCOLOR="yes"
  811.     else
  812.         # We do not want colors during emerge depend
  813.         RC_NOCOLOR="yes"
  814.         # No output is seen during emerge depend, so this is not needed.
  815.         RC_ENDCOL="no"
  816.     fi
  817. fi
  818.  
  819. if [[ -n ${EBUILD} && $* == *depend* ]]; then
  820.     # We do not want stty to run during emerge depend
  821.     COLS=80
  822. else
  823.     # Setup COLS and ENDCOL so eend can line up the [ ok ]
  824.     COLS=${COLUMNS:-0}        # bash's internal COLUMNS variable
  825.     (( COLS == 0 )) && COLS=$(stty size 2>/dev/null | cut -d' ' -f2)
  826.     (( COLS > 0 )) || (( COLS = 80 ))    # width of [ ok ] == 7
  827. fi
  828.  
  829. if [[ ${RC_ENDCOL} == yes ]]; then
  830.     ENDCOL=$'\e[A\e['$(( COLS - 7 ))'G'
  831. else
  832.     ENDCOL=''
  833. fi
  834.  
  835. # Setup the colors so our messages all look pretty
  836. if [[ ${RC_NOCOLOR} == yes ]]; then
  837.     unset GOOD WARN BAD NORMAL HILITE BRACKET
  838. else
  839.     GOOD=$'\e[32;01m'
  840.     WARN=$'\e[33;01m'
  841.     BAD=$'\e[31;01m'
  842.     HILITE=$'\e[36;01m'
  843.     BRACKET=$'\e[34;01m'
  844.     NORMAL=$'\e[0m'
  845. fi
  846.  
  847. ##############################################################################
  848. #                                                                            #
  849. # *** END LAST CODE ***                                                      #
  850. #                                                                            #
  851. # This should be the last code in here, please add all functions above!!     #
  852. #                                                                            #
  853. ##############################################################################
  854.  
  855.  
  856. # vim:ts=4
  857.